package com.mask.token.util;

import com.mask.token.model.TokenInfo;
import com.mask.token.service.MaskTokenService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.Map;

/**
 * Token解析工具类
 * 提供便捷的Token解析功能
 * 
 * 使用方式：
 * 1. 在Controller中注入此工具类
 * 2. 调用相应方法解析Token
 * 3. 获取用户信息进行业务处理
 *
 * @author mask
 * @since 1.0.0
 */
@Slf4j
@Component
@RequiredArgsConstructor
public class MaskTokenParser {

    private final MaskTokenService tokenService;

    /**
     * 解析Token并返回用户信息
     *
     * @param request HTTP请求
     * @return 用户信息Map，如果解析失败返回null
     */
    public Map<String, Object> parseTokenFromRequest(HttpServletRequest request) {
        try {
            String token = MaskTokenUtil.getTokenFromRequest(request);
            
            if (token == null) {
                log.warn("请求中未找到Token");
                return null;
            }

            return parseToken(token);
        } catch (Exception e) {
            log.error("从请求解析Token失败", e);
            return null;
        }
    }

    /**
     * 解析Token字符串
     *
     * @param token Token字符串
     * @return 用户信息Map，如果解析失败返回null
     */
    public Map<String, Object> parseToken(String token) {
        try {
            if (token == null || token.trim().isEmpty()) {
                log.warn("Token为空");
                return null;
            }

            // 验证Token
            if (!tokenService.validateToken(token)) {
                log.warn("Token无效或已过期: {}", token);
                return null;
            }

            // 获取Token信息
            TokenInfo tokenInfo = tokenService.getTokenInfo(token);
            if (tokenInfo == null) {
                log.warn("无法获取Token信息: {}", token);
                return null;
            }

            // 构建返回结果
            Map<String, Object> result = new HashMap<>();
            result.put("token", token);
            result.put("userId", tokenInfo.getUserId());
            result.put("username", tokenInfo.getUsername());
            result.put("deviceId", tokenInfo.getDeviceId());
            result.put("loginTime", tokenInfo.getLoginTime());
            result.put("expireTime", tokenInfo.getExpireTime());
            result.put("lastActiveTime", tokenInfo.getLastActiveTime());
            result.put("expireTimeSeconds", tokenService.getTokenExpireTime(token));

            log.debug("Token解析成功: userId={}, username={}", tokenInfo.getUserId(), tokenInfo.getUsername());
            return result;
        } catch (Exception e) {
            log.error("解析Token失败: {}", token, e);
            return null;
        }
    }

    /**
     * 快速获取用户ID
     *
     * @param request HTTP请求
     * @return 用户ID，如果解析失败返回null
     */
    public Long getUserIdFromRequest(HttpServletRequest request) {
        try {
            String token = MaskTokenUtil.getTokenFromRequest(request);
            if (token != null) {
                return tokenService.getUserIdFromToken(token);
            }
        } catch (Exception e) {
            log.error("从请求获取用户ID失败", e);
        }
        return null;
    }

    /**
     * 快速获取用户名
     *
     * @param request HTTP请求
     * @return 用户名，如果解析失败返回null
     */
    public String getUsernameFromRequest(HttpServletRequest request) {
        try {
            String token = MaskTokenUtil.getTokenFromRequest(request);
            if (token != null) {
                return tokenService.getUsernameFromToken(token);
            }
        } catch (Exception e) {
            log.error("从请求获取用户名失败", e);
        }
        return null;
    }

    /**
     * 检查Token是否有效
     *
     * @param request HTTP请求
     * @return 是否有效
     */
    public boolean isTokenValid(HttpServletRequest request) {
        try {
            String token = MaskTokenUtil.getTokenFromRequest(request);
            return token != null && tokenService.validateToken(token);
        } catch (Exception e) {
            log.error("检查Token有效性失败", e);
            return false;
        }
    }

    /**
     * 检查Token是否有效
     *
     * @param token Token字符串
     * @return 是否有效
     */
    public boolean isTokenValid(String token) {
        try {
            return token != null && tokenService.validateToken(token);
        } catch (Exception e) {
            log.error("检查Token有效性失败", e);
            return false;
        }
    }

    /**
     * 获取Token剩余过期时间
     *
     * @param request HTTP请求
     * @return 剩余过期时间（秒），-1表示无效
     */
    public long getTokenExpireTime(HttpServletRequest request) {
        try {
            String token = MaskTokenUtil.getTokenFromRequest(request);
            if (token != null) {
                return tokenService.getTokenExpireTime(token);
            }
        } catch (Exception e) {
            log.error("获取Token过期时间失败", e);
        }
        return -1;
    }

    /**
     * 获取Token剩余过期时间
     *
     * @param token Token字符串
     * @return 剩余过期时间（秒），-1表示无效
     */
    public long getTokenExpireTime(String token) {
        try {
            if (token != null) {
                return tokenService.getTokenExpireTime(token);
            }
        } catch (Exception e) {
            log.error("获取Token过期时间失败", e);
        }
        return -1;
    }

    /**
     * 获取Token详细信息
     *
     * @param request HTTP请求
     * @return Token详细信息，如果解析失败返回null
     */
    public TokenInfo getTokenInfoFromRequest(HttpServletRequest request) {
        try {
            String token = MaskTokenUtil.getTokenFromRequest(request);
            if (token != null) {
                return tokenService.getTokenInfo(token);
            }
        } catch (Exception e) {
            log.error("获取Token详细信息失败", e);
        }
        return null;
    }

    /**
     * 获取Token详细信息
     *
     * @param token Token字符串
     * @return Token详细信息，如果解析失败返回null
     */
    public TokenInfo getTokenInfo(String token) {
        try {
            if (token != null) {
                return tokenService.getTokenInfo(token);
            }
        } catch (Exception e) {
            log.error("获取Token详细信息失败", e);
        }
        return null;
    }

    // ==================== 直接传入Token字符串的方法 ====================

    /**
     * 直接解析Token字符串并返回用户信息
     *
     * @param token Token字符串
     * @return 用户信息Map，如果解析失败返回null
     */
    public Map<String, Object> parseTokenDirect(String token) {
        try {
            if (token == null || token.trim().isEmpty()) {
                log.warn("Token为空");
                return null;
            }

            // 验证Token
            if (!tokenService.validateToken(token)) {
                log.warn("Token无效或已过期: {}", token);
                return null;
            }

            // 获取Token信息
            TokenInfo tokenInfo = tokenService.getTokenInfo(token);
            if (tokenInfo == null) {
                log.warn("无法获取Token信息: {}", token);
                return null;
            }

            // 构建返回结果
            Map<String, Object> result = new HashMap<>();
            result.put("token", token);
            result.put("userId", tokenInfo.getUserId());
            result.put("username", tokenInfo.getUsername());
            result.put("deviceId", tokenInfo.getDeviceId());
            result.put("loginTime", tokenInfo.getLoginTime());
            result.put("expireTime", tokenInfo.getExpireTime());
            result.put("lastActiveTime", tokenInfo.getLastActiveTime());
            result.put("expireTimeSeconds", tokenService.getTokenExpireTime(token));

            log.debug("Token解析成功: userId={}, username={}", tokenInfo.getUserId(), tokenInfo.getUsername());
            return result;
        } catch (Exception e) {
            log.error("解析Token失败: {}", token, e);
            return null;
        }
    }

    /**
     * 直接获取Token中的用户ID
     *
     * @param token Token字符串
     * @return 用户ID，如果解析失败返回null
     */
    public Long getUserIdDirect(String token) {
        try {
            if (token != null) {
                return tokenService.getUserIdFromToken(token);
            }
        } catch (Exception e) {
            log.error("从Token获取用户ID失败", e);
        }
        return null;
    }

    /**
     * 直接获取Token中的用户名
     *
     * @param token Token字符串
     * @return 用户名，如果解析失败返回null
     */
    public String getUsernameDirect(String token) {
        try {
            if (token != null) {
                return tokenService.getUsernameFromToken(token);
            }
        } catch (Exception e) {
            log.error("从Token获取用户名失败", e);
        }
        return null;
    }

    /**
     * 直接检查Token是否有效
     *
     * @param token Token字符串
     * @return 是否有效
     */
    public boolean isValidDirect(String token) {
        try {
            return token != null && tokenService.validateToken(token);
        } catch (Exception e) {
            log.error("检查Token有效性失败", e);
            return false;
        }
    }

    /**
     * 直接获取Token剩余过期时间
     *
     * @param token Token字符串
     * @return 剩余过期时间（秒），-1表示无效
     */
    public long getExpireTimeDirect(String token) {
        try {
            if (token != null) {
                return tokenService.getTokenExpireTime(token);
            }
        } catch (Exception e) {
            log.error("获取Token过期时间失败", e);
        }
        return -1;
    }

    /**
     * 直接获取Token详细信息
     *
     * @param token Token字符串
     * @return Token详细信息，如果解析失败返回null
     */
    public TokenInfo getTokenInfoDirect(String token) {
        try {
            if (token != null) {
                return tokenService.getTokenInfo(token);
            }
        } catch (Exception e) {
            log.error("获取Token详细信息失败", e);
        }
        return null;
    }

    /**
     * 直接解析Token并返回简化的用户信息
     *
     * @param token Token字符串
     * @return 简化的用户信息Map，如果解析失败返回null
     */
    public Map<String, Object> parseTokenSimple(String token) {
        try {
            if (token == null || token.trim().isEmpty()) {
                return null;
            }

            // 验证Token
            if (!tokenService.validateToken(token)) {
                return null;
            }

            // 获取Token信息
            TokenInfo tokenInfo = tokenService.getTokenInfo(token);
            if (tokenInfo == null) {
                return null;
            }

            // 构建简化的返回结果
            Map<String, Object> result = new HashMap<>();
            result.put("userId", tokenInfo.getUserId());
            result.put("username", tokenInfo.getUsername());
            result.put("expireTimeSeconds", tokenService.getTokenExpireTime(token));

            return result;
        } catch (Exception e) {
            log.error("解析Token失败", e);
            return null;
        }
    }

    /**
     * 直接解析Token并返回用户ID和用户名
     *
     * @param token Token字符串
     * @return 包含userId和username的Map，如果解析失败返回null
     */
    public Map<String, Object> parseUserInfo(String token) {
        try {
            if (token == null || token.trim().isEmpty()) {
                return null;
            }

            // 验证Token
            if (!tokenService.validateToken(token)) {
                return null;
            }

            // 获取Token信息
            TokenInfo tokenInfo = tokenService.getTokenInfo(token);
            if (tokenInfo == null) {
                return null;
            }

            // 构建用户信息
            Map<String, Object> result = new HashMap<>();
            result.put("userId", tokenInfo.getUserId());
            result.put("username", tokenInfo.getUsername());

            return result;
        } catch (Exception e) {
            log.error("解析用户信息失败", e);
            return null;
        }
    }
}